home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 11 / Cream of the Crop 11-1.iso / games / ted5.zip / TED5-2.C < prev    next >
C/C++ Source or Header  |  1994-02-16  |  44KB  |  2,185 lines
  1. ////////////////////////////////////////////////////
  2. ////////////////////////////////////////////////////
  3. //
  4. // TED5-2 : Menu Item Routines
  5. //
  6. ////////////////////////////////////////////////////
  7. ////////////////////////////////////////////////////
  8. #include "ted5.h"
  9. #pragma hdrstop
  10.  
  11. ////////////////////////////////////////////////////
  12. //
  13. // Toggle the INFOBAR on and off
  14. //
  15. ////////////////////////////////////////////////////
  16. void Item_ToggleInfo(void)
  17. {
  18.  infobaron^=1;
  19.  MouseHide();
  20.  InitDesktop(TED5MenuBar,0);
  21.  FigureScreenEdges();
  22.  if (ybase+screenh>mapheight && mapheight>screenh)
  23.    ybase--;
  24.  DrawMap();
  25.  DrawInfoBar();
  26.  MouseShow();
  27. }
  28.  
  29.  
  30. ////////////////////////////////////////////////////
  31. //
  32. // Tile Select
  33. //
  34. ////////////////////////////////////////////////////
  35. btype SelTb[]={{" Tiles ",2,21,1},
  36.            {" Masked ",11,21,1},
  37.            {" Icons ",21,21,1},
  38.            {" Exit ",30,21,2}};
  39. DialogDef SelTd={"",38,23,4,&SelTb[0],NULL};
  40.  
  41. void SelectTiles(int screen)
  42. {
  43.  int exitok=0,which,i,numrows,numcols,b0,b1,redraw=0;
  44.  
  45.  //
  46.  // if parameter passed, change the screen
  47.  //
  48.  if (screen)
  49.    whichscreen=screen-1;
  50.  
  51.  if (PasteMode || SelectMode)   // RE-BLIT MAP IF WE ARE ENTERING WHILE
  52.    redraw=1;                    // FLOATING AN IMAGE
  53.  
  54.  PasteMode=SelectMode=0;
  55.  SelX1=SelX2=SelY1=SelY2=-1;
  56.  
  57.  switch(videomode)
  58.  {
  59.   case CGA:
  60.   case EGA1:
  61.   case VGA:
  62.      SelTd.height=23;
  63.     for(i=0;i<4;i++)
  64.       SelTb[i].yoff=21;
  65.     break;
  66.   case EGA2:
  67.     SelTd.height=58;
  68.     for(i=0;i<4;i++)
  69.       SelTb[i].yoff=56;
  70.  }
  71.  
  72.  DrawDialog(&SelTd,1);
  73.  DrawTileSelect(0,&numrows,&numcols);
  74.  selectcols=numcols;    // VERY IMPORTANT TO PASTE-FROM-TILESELECT MODE
  75.  DrawCurrentTiles();
  76.  while(keydown[0x39]);  // WAIT FOR SPACE-UP
  77.  
  78.  do
  79.  {
  80.   which=CheckButtonsRet(&SelTd);
  81.   b0=MouseButton()&1;
  82.   b1=(MouseButton()>>1)&1;
  83.  
  84.   if (which<0)
  85.     {
  86.      //
  87.      // GRAB CURRENT TILE FROM MATRIX
  88.      //
  89.      if (b0 || b1)
  90.        {
  91.     int mx,my;
  92.  
  93.     MouseCoords(&mx,&my);
  94.     mx/=8;
  95.     if (mx>=left && mx<left+(numcols<<(tsize-1)) &&
  96.         my>=16 && my<=16+(numrows<<(2+tsize)))
  97.       {
  98.        int tile;
  99.  
  100.        tile=((my-16)>>(tsize+2))*numcols+
  101.         ((mx-left)>>(tsize-1));
  102.  
  103.        if (SelectMode)
  104.          {
  105.           int thebase;
  106.           switch(whichscreen)
  107.             {
  108.            case TILES: thebase=tilebase/numcols; break;
  109.            case MASKED: thebase=tilembase/numcols;
  110.           }
  111.  
  112.           if (b0)
  113.         {
  114.          sound(1000);
  115.          SelY1=((my-16)>>(tsize+2))+thebase;
  116.          SelX1=((mx-left)>>(tsize-1));
  117.          if (SelX2==-1 && SelY2==-1)
  118.            {
  119.             SelX2=SelX1;
  120.             SelY2=SelY1;
  121.            }
  122.          DrawTileSelect(0,&numrows,&numcols);
  123.          nosound();
  124.         }
  125.           else
  126.           if (b1)
  127.         {
  128.          sound(1000);
  129.          SelY2=((my-16)>>(tsize+2))+thebase;
  130.          SelX2=((mx-left)>>(tsize-1));
  131.          if (SelX1==-1 && SelY1==-1)
  132.            {
  133.             SelX1=SelX2;
  134.             SelY1=SelY2;
  135.            }
  136.          DrawTileSelect(0,&numrows,&numcols);
  137.          nosound();
  138.         }
  139.          }
  140.        else
  141.          {
  142.           switch(whichscreen)
  143.           {
  144.            case TILES:
  145.          if (XMSlookup[tile+tilebase]>=0)
  146.            whicht=tile+tilebase;
  147.          else
  148.            errsound();
  149.          break;
  150.            case MASKED:
  151.          whichtm=tile+tilembase+numcols*maxiconrows+tilenum;
  152.          if (XMSlookup[whichtm]==-1)
  153.            whichtm=tilenum;
  154.          break;
  155.            case ICONS:
  156.          if (XMSlookup[tile+tilenum]>=0 || !tile)
  157.            whichi=tile+tilenum;
  158.          else
  159.            errsound();
  160.          break;
  161.           }
  162.           DrawCurrentTiles();
  163.          }
  164.       }
  165.        }
  166.  
  167.      if (keydown[0x48])                 // UP
  168.        DrawTileSelect(-1,&numrows,&numcols);
  169.      else
  170.      if (keydown[0x50])                 // DOWN
  171.        DrawTileSelect(1,&numrows,&numcols);
  172.      else
  173.      if (keydown[0x47])                 // HOME
  174.        {
  175.     if (whichscreen==TILES)
  176.       DrawTileSelect(-tilebase/numcols,&numrows,&numcols);
  177.     else
  178.     if (whichscreen==MASKED)
  179.       DrawTileSelect(-tilembase/numcols,&numrows,&numcols);
  180.        }
  181.      else
  182.      if (keydown[0x4f])                 // END
  183.        {
  184.     if (whichscreen==TILES)
  185.       DrawTileSelect(tilenum,&numrows,&numcols);
  186.     else
  187.     if (whichscreen==MASKED)
  188.       DrawTileSelect(tilemnum,&numrows,&numcols);
  189.        }
  190.      else
  191.      if (keydown[0x49])                 // PgUP
  192.        {
  193.     DrawTileSelect(-numrows,&numrows,&numcols);
  194.     if (!keydown[0x1d])     // if not CTRL down, wait for keyup
  195.       while(keydown[0x49]);
  196.        }
  197.       else
  198.      if (keydown[0x51])                 // PgDN
  199.        {
  200.     DrawTileSelect(numrows,&numrows,&numcols);
  201.     if (!keydown[0x1d])     // if not CTRL down, wait for keyup
  202.       while(keydown[0x51]);
  203.        }
  204.      else
  205.      if (keydown[0x39])                 // SPACEBAR
  206.        {
  207.     RestoreBackground();
  208.     while(keydown[0x39]);
  209.     SelectMode=0;
  210.     if (redraw)
  211.       DrawMap();
  212.     DrawInfoBar();
  213.     return;
  214.        }
  215.      else                               // 'C' TO COPY
  216.      if (keydown[0x2e] && (whichscreen==TILES || whichscreen==MASKED))
  217.        {
  218.     char temp[]="COPY MODE";
  219.  
  220.     sx=screencenterx-strlen(temp)/2;
  221.     SelectMode=sy=1;
  222.     print(temp);
  223.  
  224.     while(keydown[0x2e]);
  225.        }
  226.     }
  227.   else
  228.     switch(which)
  229.     {
  230.      case 0:
  231.        if (!SelectMode)
  232.      exitok=1;
  233.        else
  234.      {
  235.       char temp[]="         ";
  236.  
  237.       sx=screencenterx-strlen(temp)/2;
  238.       SelectMode=0;
  239.       SelX1=SelX2=SelY1=SelY2=-1;
  240.       sy=1;
  241.       print(temp);
  242.       DrawTileSelect(0,&numrows,&numcols);
  243.      }
  244.        break;
  245.  
  246.      case 4:
  247.        if (!SelectMode)
  248.      exitok=1;
  249.        //
  250.        // 'ENTER' TO FINALIZE COPY
  251.        //
  252.        else
  253.      {
  254.       char temp[]="         ";
  255.  
  256.       if (MouseButton())    // IF CLICKED ON 'EXIT' WITH MOUSE
  257.         break;
  258.  
  259.       sound(500);
  260.       sx=screencenterx-strlen(temp)/2;
  261.       PasteOK=sy=1;
  262.       print(temp);
  263.  
  264.       TileCopy.x=SelX1;
  265.       TileCopy.y=SelY1;
  266.       TileCopy.w=SelX2-SelX1+1;
  267.       TileCopy.h=SelY2-SelY1+1;
  268.       TileCopy.MapOrTileSelect=(whichscreen==TILES)+2*(whichscreen==MASKED);
  269.  
  270.       while(keydown[0x1c]);
  271.       nosound();
  272.       SelectMode=0;
  273.       SelX1=SelX2=SelY1=SelY2=-1;
  274.       DrawTileSelect(0,&numrows,&numcols);
  275.      }
  276.        break;
  277.      //
  278.      // NORMAL TILE SELECT
  279.      //
  280.      case 1:
  281.        if (whichscreen!=TILES)
  282.      {
  283.       SelX1=SelX2=SelY1=SelY2=-1;
  284.       SelectMode=0;
  285.       whichscreen=TILES;
  286.       DrawDialog(&SelTd,0);
  287.       DrawCurrentTiles();
  288.       DrawTileSelect(0,&numrows,&numcols);
  289.      }
  290.        else
  291.      errsound();
  292.        GetButtonXY(&SelTd,0,&sx,&sy);
  293.        MouseHide();
  294.        print(SelTb[0].text);
  295.        MouseShow();
  296.        break;
  297.      //
  298.      // MASKED TILE SELECT
  299.      //
  300.      case 2:
  301.        if (tilemnum && whichscreen!=MASKED)
  302.      {
  303.       SelX1=SelX2=SelY1=SelY2=-1;
  304.       SelectMode=0;
  305.       whichscreen=MASKED;
  306.       DrawDialog(&SelTd,0);
  307.       DrawCurrentTiles();
  308.       DrawTileSelect(0,&numrows,&numcols);
  309.      }
  310.        else
  311.      errsound();
  312.        GetButtonXY(&SelTd,1,&sx,&sy);
  313.        MouseHide();
  314.        print(SelTb[1].text);
  315.        MouseShow();
  316.        break;
  317.      //
  318.      // ICON SELECT
  319.      //
  320.      case 3:
  321.        if (tilemnum && whichscreen!=ICONS)
  322.      {
  323.       whichscreen=ICONS;
  324.       DrawDialog(&SelTd,0);
  325.       DrawCurrentTiles();
  326.       DrawTileSelect(0,&numrows,&numcols);
  327.      }
  328.        else
  329.      errsound();
  330.        GetButtonXY(&SelTd,2,&sx,&sy);
  331.        MouseHide();
  332.          print(SelTb[2].text);
  333.        MouseShow();
  334.     }
  335.  
  336.  } while(!exitok);
  337.  RestoreBackground();
  338.  SelectMode=0;
  339.  SelX1=SelX2=SelY1=SelY2=-1;
  340.  DrawInfoBar();
  341.  if (redraw)
  342.    DrawMap();
  343. }
  344.  
  345.  
  346. //
  347. // DRAW THE CURRENT TILES IN THE TILE-SELECT WINDOW
  348. //
  349. void DrawCurrentTiles(void)
  350. {
  351.  MouseHide();
  352.  GetButtonXY(&SelTd,0,&sx,&sy);
  353.  sy-=1+tsize;
  354.  CombineTiles(whicht,0,0,tsize);
  355.  DrawTile(sx,sy*8,tsize);
  356.  sx+=2;
  357.  printhex(whicht);
  358.  sy++;
  359.  sx-=5;
  360.  printint(whicht);
  361.  print("   ");
  362.  
  363.  if (tilemnum)
  364.    {
  365.     GetButtonXY(&SelTd,1,&sx,&sy);
  366.     sy-=1+tsize;
  367.     CombineTiles(-BkgndColor,whichtm,0,tsize);
  368.     DrawTile(sx,sy*8,tsize);
  369.     sx+=2;
  370.     (whichtm==tilenum)?print(" No  "):printhex(whichtm-tilenum);
  371.  
  372.     sy++;
  373.     sx-=5;
  374.     (whichtm==tilenum)?print(" Tile "):printint(whichtm-tilenum);
  375.     print("    ");
  376.  
  377.      GetButtonXY(&SelTd,2,&sx,&sy);
  378.     sy-=1+tsize;
  379.     CombineTiles(-ICONBACK,whichi,0,tsize);
  380.     DrawTile(sx,sy*8,tsize);
  381.     sx+=2;
  382.     (whichi==tilenum)?print(" No  "):printhex(whichi-tilenum);
  383.     sy++;
  384.     sx-=5;
  385.     (whichi==tilenum)?print(" Icon "):printint(whichi-tilenum);
  386.     print("    ");
  387.    }
  388.  MouseShow();
  389. }
  390.  
  391.  
  392. //
  393. // CHECK TILESELECT EDGES
  394. //
  395. void CheckTSelectEdges(int x,int y,int basey)
  396. {
  397.  int xx,yy,temp;
  398.  
  399.  xx=left+(x<<(tsize-1));
  400.  yy=(y<<(tsize-1))+2;
  401.  
  402.  if (SelX2<SelX1)
  403.    {
  404.     temp=SelX1;
  405.     SelX1=SelX2;
  406.     SelX2=temp;
  407.    }
  408.  
  409.  if (SelY2<SelY1)
  410.    {
  411.     temp=SelY1;
  412.     SelY1=SelY2;
  413.     SelY2=temp;
  414.    }
  415.  
  416.  if (x==SelX1 && y==SelY1-basey)
  417.    {
  418.     switch(tsize)
  419.     {
  420.      case 1: drawchar(xx,yy,1); return;
  421.      case 2: drawchar(xx  ,yy,1);
  422.           drawchar(xx+1,yy,2);
  423.          drawchar(xx  ,yy+1,4);
  424.          break;
  425.      case 3: drawchar(xx,yy,1);
  426.  
  427.          drawchar(xx,yy+1,4);
  428.          drawchar(xx,yy+2,4);
  429.          drawchar(xx,yy+3,4);
  430.  
  431.          drawchar(xx+1,yy,2);
  432.          drawchar(xx+2,yy,2);
  433.          drawchar(xx+3,yy,2);
  434.  
  435.          break;
  436.     }
  437.    }
  438.  if (x==SelX2 && y==SelY2-basey)
  439.    {
  440.     switch(tsize)
  441.     {
  442.      case 1: drawchar(xx,yy,8); return;
  443.      case 2: drawchar(xx+1,yy+1,8);
  444.          drawchar(xx+1,yy,5);
  445.          drawchar(xx,yy+1,7);
  446.          break;
  447.      case 3: drawchar(xx+3,yy+3,8);
  448.  
  449.          drawchar(xx+3,yy  ,5);
  450.          drawchar(xx+3,yy+1,5);
  451.          drawchar(xx+3,yy+2,5);
  452.  
  453.          drawchar(xx  ,yy+3,7);
  454.          drawchar(xx+1,yy+3,7);
  455.          drawchar(xx+2,yy+3,7);
  456.          break;
  457.     }
  458.    }
  459.  if (x==SelX2 && y==SelY1-basey)
  460.    {
  461.     switch(tsize)
  462.     {
  463.      case 1: drawchar(xx,yy,3); return;
  464.      case 2: drawchar(xx+1,yy,3);
  465.          drawchar(xx,yy,2);
  466.          drawchar(xx+1,yy+1,5);
  467.           break;
  468.      case 3: drawchar(xx+3,yy,3);
  469.  
  470.          drawchar(xx+2,yy,2);
  471.          drawchar(xx+1,yy,2);
  472.          drawchar(xx  ,yy,2);
  473.  
  474.          drawchar(xx+3,yy+1,5);
  475.          drawchar(xx+3,yy+2,5);
  476.          drawchar(xx+3,yy+3,5);
  477.          break;
  478.     }
  479.    }
  480.  if (x==SelX1 && y==SelY2-basey)
  481.    {
  482.     switch(tsize)
  483.     {
  484.      case 1: drawchar(xx,yy,6); return;
  485.      case 2: drawchar(xx,yy+1,6);
  486.          drawchar(xx+1,yy+1,7);
  487.          drawchar(xx,yy,4);
  488.          break;
  489.      case 3: drawchar(xx,yy+3,6);
  490.  
  491.          drawchar(xx  ,yy+2,4);
  492.          drawchar(xx  ,yy+1,4);
  493.          drawchar(xx  ,yy,4);
  494.  
  495.          drawchar(xx+1,yy+3,7);
  496.          drawchar(xx+2,yy+3,7);
  497.          drawchar(xx+3,yy+3,7);
  498.          break;
  499.     }
  500.    }
  501.  
  502.  if (x==SelX1 && y>SelY1-basey && y<SelY2-basey)
  503.    {
  504.     switch(tsize)
  505.     {
  506.      case 3: drawchar(xx,yy+3,4);
  507.          drawchar(xx,yy+2,4);
  508.      case 2: drawchar(xx,yy+1,4);
  509.      case 1: drawchar(xx,yy,4);
  510.          break;
  511.     }
  512.     }
  513.  else
  514.  if (y==SelY1-basey && x>SelX1 && x<SelX2)
  515.    {
  516.     switch(tsize)
  517.     {
  518.      case 3: drawchar(xx+3,yy,2);
  519.          drawchar(xx+2,yy,2);
  520.      case 2: drawchar(xx+1,yy,2);
  521.      case 1: drawchar(xx  ,yy,2);
  522.          break;
  523.     }
  524.    }
  525.  else
  526.  if (x==SelX2 && y>SelY1-basey && y<SelY2-basey)
  527.    {
  528.     switch(tsize)
  529.     {
  530.      case 1: drawchar(xx,yy,5); return;
  531.      case 2: drawchar(xx+1,yy,5);
  532.          drawchar(xx+1,yy+1,5);
  533.          break;
  534.      case 3: drawchar(xx+3,yy,5);
  535.          drawchar(xx+3,yy+1,5);
  536.          drawchar(xx+3,yy+2,5);
  537.          drawchar(xx+3,yy+3,5);
  538.          break;
  539.     }
  540.    }
  541.  else
  542.  if (y==SelY2-basey && x>SelX1 && x<SelX2)
  543.    {
  544.     switch(tsize)
  545.     {
  546.      case 1: drawchar(xx,yy,7); return;
  547.      case 2: drawchar(xx  ,yy+1,7);
  548.          drawchar(xx+1,yy+1,7);
  549.          break;
  550.      case 3: drawchar(xx  ,yy+3,7);
  551.          drawchar(xx+1,yy+3,7);
  552.          drawchar(xx+2,yy+3,7);
  553.          drawchar(xx+3,yy+3,7);
  554.          break;
  555.     }
  556.    }
  557. }
  558.  
  559.  
  560.  
  561. //
  562. // FILL THE TILE SELECT SCREEN WITH TILES
  563. //
  564. void DrawTileSelect(int deltarow,int *retrows,int *retcols)
  565. {
  566.  char tile[32*32];
  567.  int numcols,numrows,i,j;
  568.  
  569.  MouseHide();
  570.  switch(videomode)
  571.  {
  572.   case CGA:
  573.   case EGA1:
  574.   case VGA:
  575.     numrows=18-10*(tsize==2)-15*(tsize==3);
  576.     left=2;
  577.     break;
  578.   case EGA2:
  579.     numrows=49-23*(tsize==2)-34*(tsize==3);
  580.     left=22;
  581.  }
  582.  
  583.  switch(tsize)
  584.  {
  585.   case 1: numcols=36; break;
  586.   case 2: numcols=18; break;
  587.   case 3: numcols=9;
  588.  }
  589.  
  590.  if (whichscreen==TILES && tilebase+numrows*numcols>tilenum)
  591.    {
  592.     tilebase=0;
  593.     numrows=tilenum/numcols;
  594.    }
  595.  
  596.  if (whichscreen==MASKED && tilembase+numrows*numcols>tilemnum-maxiconrows*numcols)
  597.    {
  598.     tilembase=0;
  599.     numrows=tilemnum/numcols-maxiconrows;
  600.    }
  601.  
  602.  if (whichscreen==ICONS && numrows*numcols>maxiconrows*numcols)
  603.    {
  604.     tilembase=0;
  605.     numrows=maxiconrows;
  606.    }
  607.  
  608.  switch((deltarow<0?-1:deltarow>0?1:0))
  609.  {
  610.   case -1:
  611.    switch(whichscreen)
  612.    {
  613.     case TILES:
  614.       tilebase+=deltarow*numcols;
  615.       if (tilebase<0)
  616.     tilebase=0;
  617.       break;
  618.     case MASKED:
  619.       tilembase+=deltarow*numcols;
  620.       if (tilembase<0)
  621.     tilembase=0;
  622.    }
  623.    break;
  624.   case 1:
  625.    switch(whichscreen)
  626.    {
  627.     case TILES:
  628.       tilebase+=deltarow*numcols;
  629.       if (tilebase+numrows*numcols>tilenum)
  630.     tilebase=tilenum-numcols*numrows;
  631.       break;
  632.     case MASKED:
  633.       tilembase+=deltarow*numcols;
  634.       if (tilembase+numrows*numcols>tilemnum-maxiconrows*numcols)
  635.     tilembase=(tilemnum-maxiconrows*numcols)-numcols*numrows;
  636.    }
  637.  }
  638.  
  639.  switch(whichscreen)
  640.  {
  641.   case TILES:
  642.     for(j=0;j<numrows;j++)
  643.       for(i=0;i<numcols;i++)
  644.       {
  645.        CombineTiles(tilebase+j*numcols+i,0,0,tsize);
  646.        if (GridMode)
  647.      Overlay(tsize);
  648.        DrawTile(i*2+left,j*16+16,tsize);
  649.        CheckTSelectEdges(i,j,tilebase/numcols);
  650.       }
  651.     break;
  652.  
  653.   case MASKED:
  654.     for(j=0;j<numrows;j++)
  655.       for(i=0;i<numcols;i++)
  656.       {
  657.        CombineTiles(-BkgndColor,tilenum+numcols*maxiconrows+tilembase+j*numcols+i,0,tsize);
  658.        if (GridMode)
  659.      Overlay(tsize);
  660.        DrawTile(i*2+left,j*16+16,tsize);
  661.        CheckTSelectEdges(i,j,tilembase/numcols);
  662.       }
  663.     break;
  664.  
  665.   default:
  666.     for(j=0;j<numrows;j++)
  667.       for(i=0;i<numcols;i++)
  668.       {
  669.        CombineTiles(-ICONBACK,tilenum+j*numcols+i,0,tsize);
  670.        if (GridMode)
  671.      Overlay(tsize);
  672.        DrawTile(i*2+left,j*16+16,tsize);
  673.       }
  674.  }
  675.  MouseShow();
  676.  
  677.  *retrows=numrows;
  678.  *retcols=numcols;
  679. }
  680.  
  681.  
  682.  
  683. void errsound(void)
  684. {
  685.  sound(1000);
  686.  delay(50);
  687.  nosound();
  688. }
  689.  
  690.  
  691. ////////////////////////////////////////////////////
  692. //
  693. // Item - About
  694. //
  695. ////////////////////////////////////////////////////
  696. void Item_About(void)
  697. {
  698.  char dstr[200]=IDSTSTR;
  699.  
  700.  strcat(dstr,"\n\n   IdWare by John Romero\n");
  701.  strcat(dstr,"        ");
  702.  strcat(dstr,__DATE__);
  703.  strcat(dstr,"\n    (C)1991 Id Software\n\n"
  704.          " DeluxePaint for Tile Maps! ");
  705.  
  706.  ErrDialog(dstr," OK ");
  707. }
  708.  
  709. ////////////////////////////////////////////////////
  710. //
  711. // Item - Video Mode Switch
  712. //
  713. ////////////////////////////////////////////////////
  714. btype VMS1b[]={{" CGA 320x200 ",5,2,1},
  715.            {" EGA 320x200 ",5,5,1},
  716.              {" EGA 640x350 ",5,8,1},
  717.            {" VGA 320x200 ",5,11,1}};
  718. DialogDef VMS1d={"Select the resolution:",22,14,4,&VMS1b[0],NULL};
  719.  
  720. void Item_ModeSwitch(void)
  721. {
  722.  int i,which,rtn;
  723.  
  724.  for(i=0;i<VMS1d.numbuttons;i++)
  725.    {
  726.     VMS1b[i].border=1;
  727.     if (i==lastvideo)
  728.       VMS1b[i].border=2;
  729.    }
  730.  
  731. // which=DoDialog(&VMS1d);
  732.  //
  733.  // Keep track of last video mode!
  734.  //
  735.  if (videomode==EGA1)
  736.      {
  737.      which=3;
  738.      lastvideo=videomode;
  739.      }
  740.  else
  741.      {
  742.      which=2;
  743.      lastvideo=videomode;
  744.      }
  745.  
  746.  MouseHide();
  747.  switch(which)
  748.  {
  749.   case 0:
  750.      MouseShow();
  751.      return;
  752.   case 1:
  753.      if (!CgaXMS)
  754.         {
  755.          rtn=LoadGraphStuff(1,CGA);
  756.          if (!rtn)
  757.      {
  758.       MouseShow();
  759.       ErrDialog("There aren't any CGA\n"
  760.              "graphics files available!"," OK ");
  761.       return;
  762.      }
  763.          if (rtn<0)
  764.      return;
  765.          MouseShow();
  766.         }
  767.      else
  768.         {
  769.          xmshandle=CgaXMS;
  770.          XMSlookup=CgaXMSlookup;
  771.         }
  772.      setvideo(CGA);
  773.      break;
  774.   case 2:
  775.      if (!EgaXMS)
  776.         {
  777.          rtn=LoadGraphStuff(1,EGA1);
  778.          if (!rtn)
  779.      {
  780.       MouseShow();
  781.       ErrDialog("There aren't any EGA\n"
  782.              "graphics files available!"," OK ");
  783.       return;
  784.      }
  785.          if (rtn<0)
  786.      return;
  787.          MouseShow();
  788.         }
  789.      else
  790.       {
  791.        xmshandle=EgaXMS;
  792.        XMSlookup=EgaXMSlookup;
  793.       }
  794.     setvideo(EGA1);
  795.     break;
  796.   case 3:
  797.     if (!EgaXMS)
  798.       {
  799.        rtn=LoadGraphStuff(1,EGA1);
  800.        if (!rtn)
  801.      {
  802.       MouseShow();
  803.       ErrDialog("There aren't any EGA\n"
  804.             "graphics files available!"," OK ");
  805.       return;
  806.      }
  807.        if (rtn<0)
  808.      return;
  809.        MouseShow();
  810.       }
  811.     else
  812.       {
  813.        xmshandle=EgaXMS;
  814.        XMSlookup=EgaXMSlookup;
  815.       }
  816.     setvideo(EGA2);
  817.     break;
  818.   case 4:
  819.     if (!VgaXMS)
  820.       {
  821.        rtn=LoadGraphStuff(1,VGA);
  822.        if (!rtn)
  823.      {
  824.       MouseShow();
  825.       ErrDialog("There aren't any VGA\n"
  826.             "graphics files available!"," OK ");
  827.       return;
  828.      }
  829.        if (rtn<0)
  830.      return;
  831.        MouseShow();
  832.         }
  833.      else
  834.       {
  835.        xmshandle=VgaXMS;
  836.        XMSlookup=VgaXMSlookup;
  837.       }
  838.     setvideo(VGA);
  839.  }
  840.  
  841.  InitDesktop(TED5MenuBar,0);
  842.  DrawInfoBar();
  843.  FigureScreenEdges();
  844.  
  845.  if (xbase+screenw>mapwidth)
  846.    xbase=mapwidth-screenw;
  847.  if (mapwidth<screenw)
  848.    xbase=0;
  849.  if (ybase+screenh>mapheight)
  850.    ybase=mapheight-screenh;
  851.  if (mapheight<screenh)
  852.    ybase=0;
  853.  
  854.  DrawMap();
  855.  MouseShow();
  856. }
  857.  
  858. ////////////////////////////////////////////////////
  859. //
  860. // Item - Map Stats
  861. //
  862. ////////////////////////////////////////////////////
  863. btype MapStatsb={" OK ",11,11,2};
  864. DialogDef MapStatsd={"        MAP STATS\n\n"
  865.              "Width   :\n"
  866.              "Height  :\n"
  867.              "Name    :\n"
  868.              "Planes  :",
  869.              24,13,1,&MapStatsb,NULL};
  870.  
  871. void Item_MapStats(void)
  872. {
  873.  int ox,oy;
  874.  unsigned i,_seg *unique;
  875.  
  876.  DrawDialog(&MapStatsd,1);
  877.  MouseHide();
  878.  GetDialogXY(&MapStatsd,&sx,&sy);
  879.  ox=sx+9;
  880.  oy=sy+2;
  881.  sx=ox;
  882.  sy=oy;
  883.  printint(mapwidth);
  884.  sx=ox;
  885.  sy=oy+1;
  886.  printint(mapheight);
  887.  sx=ox;
  888.  sy=oy+2;
  889.  print(MapHeader.name);
  890.  sx=ox;
  891.  sy=oy+3;
  892.  
  893.  if (MapFileHeader->maptype&BPLANE)
  894.    print("BACK");
  895.  if (MapFileHeader->maptype&FPLANE)
  896.    print(",FORE");
  897.  if (MapFileHeader->maptype&IPLANE)
  898.    print(",INFO");
  899.  
  900.  //
  901.  // Count amount of unique background tiles
  902.  //
  903.  sx=ox-9;
  904.  sy=oy+4;
  905.  if (MapFileHeader->maptype&BPLANE)
  906.    {
  907.     int amount=0;
  908.  
  909.     print("Unique Bkgnd Tiles:");
  910.     MMAllocate((memptr *)&unique,tilenum*2);
  911.     _fmemset(unique,0,tilenum*2);
  912.     for (i=0;i<mapwidth*mapheight;i++)
  913.       unique[MapBkgnd[i]]=1;
  914.     for (i=0;i<tilenum;i++)
  915.       amount+=unique[i];
  916.     MMFreePtr((memptr *)&unique);
  917.      printint(amount);
  918.    }
  919.  
  920.  //
  921.  // Count amount of unique foreground tiles
  922.  //
  923.  sx=ox-9;
  924.  sy=oy+5;
  925.  if (MapFileHeader->maptype&FPLANE)
  926.    {
  927.     int amount=0;
  928.  
  929.     print("Unique Frgnd Tiles:");
  930.     MMAllocate((memptr *)&unique,tilemnum*2);
  931.     _fmemset(unique,0,tilemnum*2);
  932.     for (i=0;i<mapwidth*mapheight;i++)
  933.       if (MapFrgnd[i])
  934.     unique[MapFrgnd[i]]=1;
  935.     for (i=0;i<tilemnum;i++)
  936.       amount+=unique[i];
  937.     MMFreePtr((memptr *)&unique);
  938.     printint(amount);
  939.    }
  940.  
  941.  //
  942.  // Count amount of icons
  943.  //
  944.  sx=ox-9;
  945.  sy=oy+6;
  946.  if (MapFileHeader->maptype&IPLANE)
  947.    {
  948.     int amount=0;
  949.  
  950.     print("Amount of Icons:");
  951.     for (i=0;i<mapwidth*mapheight;i++)
  952.       if (MapInfoPl[i])
  953.     amount++;
  954.     printint(amount);
  955.    }
  956.  
  957.  //
  958.  // Display amount of memory the map needs
  959.  //
  960.  sx=ox-9;
  961.  sy=oy+7;
  962.  {
  963.   long length=0;
  964.  
  965.   if (MapFileHeader->maptype&BPLANE)
  966.     length+=2L*mapwidth*mapheight;
  967.   if (MapFileHeader->maptype&FPLANE)
  968.      length+=2L*mapwidth*mapheight;
  969.   if (MapFileHeader->maptype&IPLANE)
  970.     length+=2L*mapwidth*mapheight;
  971.   length+=sizeof(MapHeaderStr);
  972.  
  973.   print("Size of map:");
  974.   length=(length+1023)/1024;
  975.   printint(length);
  976.   print("K");
  977.  }
  978.  
  979.  MouseShow();
  980.  CheckButtons(&MapStatsd);
  981.  RestoreBackground();
  982. }
  983.  
  984.  
  985. ////////////////////////////////////////////////////
  986. //
  987. // Item - Edit New Map
  988. //
  989. ////////////////////////////////////////////////////
  990. btype DOSAVEb[]={{" Yes ",3,3,2},
  991.          {" No! ",15,3,1}};
  992. DialogDef DOSAVEd={"Your map has changed!\n"
  993.            "       Save it?",
  994.            21,5,2,&DOSAVEb[0],NULL};
  995.  
  996. void Item_EditMap(void)
  997. {
  998.  int which,olddirt;
  999.  
  1000.  olddirt=DirtyFlag;
  1001.  if (DirtyFlag)
  1002.    {
  1003.     which=DoDialog(&DOSAVEd);
  1004.     if (!which)
  1005.       return;
  1006.     if (which==1)
  1007.         Item_SaveMap();
  1008.     DirtyFlag=0;
  1009.    }
  1010.  
  1011.  if ((which=SelectMap(1,CREATED,"TO EDIT"))==-1)
  1012.    {
  1013.      DirtyFlag=olddirt;
  1014.     return;
  1015.    }
  1016.  
  1017.  TEDInfo->level=whichmap=which;
  1018.  LoadMap(whichmap);
  1019.  MouseHide();
  1020.  InitDesktop(TED5MenuBar,0);
  1021.  DrawInfoBar();
  1022.  FigureScreenEdges();
  1023.  DrawMap();
  1024.  MouseShow();
  1025. }
  1026.  
  1027. ////////////////////////////////////////////////////
  1028. //
  1029. // Item - Save Map
  1030. //
  1031. ////////////////////////////////////////////////////
  1032. void Item_SaveMap(void)
  1033. {
  1034.  SaveMap(0);
  1035.  DirtyFlag=0;
  1036. }
  1037.  
  1038. ////////////////////////////////////////////////////
  1039. //
  1040. // Item - Create Map
  1041. //
  1042. ////////////////////////////////////////////////////
  1043. void Item_CreateMap(void)
  1044. {
  1045.  if (DirtyFlag)
  1046.    {
  1047.     int button;
  1048.  
  1049.     button=DoDialog(&DoCreated);
  1050.     if (!button)
  1051.       return;
  1052.      if (button==1)
  1053.       Item_SaveMap();
  1054.     DirtyFlag=0;
  1055.    }
  1056.  
  1057.  CreateMap(1);
  1058.  MouseHide();
  1059.  InitDesktop(TED5MenuBar,0);
  1060.  DrawInfoBar();
  1061.  FigureScreenEdges();
  1062.  DrawMap();
  1063.  MouseShow();
  1064. }
  1065.  
  1066. ////////////////////////////////////////////////////
  1067. //
  1068. // Item - Delete Map
  1069. //
  1070. ////////////////////////////////////////////////////
  1071. btype AreSureB[]={{" Yes ",1,4,1},
  1072.           {" No ",11,4,2}};
  1073. DialogDef AreSureD={"Are you sure you\n"
  1074.             "you want to delete",
  1075.             18,6,2,&AreSureB[0],NULL};
  1076.  
  1077. void Item_DeleteMap(void)
  1078. {
  1079.  MapHeaderStr TempHead;
  1080.  int whichdel,which,temp;
  1081.  
  1082.  if ((whichdel=SelectMap(1,CREATED,"TO DELETE"))==-1)
  1083.    return;
  1084.  
  1085.  if (whichmap==whichdel)
  1086.    {
  1087.     ErrDialog("I'm just not gonna stand for\n"
  1088.          "you deleting the map you're\n"
  1089.          "currently editing. I'm not\n"
  1090.          "gonna doit. Nope."," Gee... ");
  1091.     return;
  1092.    }
  1093.  
  1094.  LoadFile(mapname,(char huge *)&TempHead,
  1095.     MapFileHeader->dataoffsets[whichdel],sizeof(MapHeaderStr));
  1096.  MouseHide();
  1097.  DrawDialog(&AreSureD,1);
  1098.  GetDialogXY(&AreSureD,&sx,&sy);
  1099.  sy+=2;
  1100.  sx=screencenterx-(strlen(TempHead.name)+1)/2;
  1101.  print(TempHead.name);
  1102.  print("?");
  1103.  MouseShow();
  1104.  
  1105.  which=CheckButtons(&AreSureD);
  1106.  switch(which)
  1107.  {
  1108.   case 1:
  1109.     temp=whichmap;
  1110.     whichmap=whichdel;
  1111.     RestoreBackground();
  1112.     SaveMap(1);
  1113.     whichmap=temp;
  1114.     return;
  1115.  }
  1116.  RestoreBackground();
  1117. }
  1118.  
  1119. ////////////////////////////////////////////////////
  1120. //
  1121. // Item - Amputate Maps
  1122. //
  1123. ////////////////////////////////////////////////////
  1124. void Item_Amputate(void)
  1125. {
  1126.     char tstr[40];
  1127.     MapHeaderStr TempHead;
  1128.     int which1,which2,whichtemp,i,button;
  1129.     long temp;
  1130.  
  1131.  
  1132.     if ((which1 = SelectMap(1,CREATED,"TO START AMPUTATE"))==-1)
  1133.         return;
  1134.  
  1135.     LoadFile(mapname,(char huge *)&TempHead,
  1136.         MapFileHeader->dataoffsets[which1],sizeof(MapHeaderStr));
  1137.  
  1138.     if ((which2 = SelectMap(1,ANYLIST,"TO END AMPUTATE"))==-1)
  1139.         return;
  1140.  
  1141.     if (which2 < which1)
  1142.     {
  1143.         whichtemp = which1;
  1144.         which1 = which2;
  1145.         which2 = whichtemp;
  1146.     }
  1147.  
  1148.     if (whichmap >= which1 && whichmap <= which2)
  1149.     {
  1150.         ErrDialog (    "The currently loaded map\n"
  1151.                     "is within that range!\n"
  1152.                     "NON-AMPUTATENESS!!","Wah!");
  1153.         return;
  1154.     }
  1155.  
  1156.     DrawDialog(&AreSureD,1);
  1157.     button = CheckButtons(&AreSureD);
  1158.     switch (button)
  1159.     {
  1160.         case 1:
  1161.             for (i = which1;i <= which2;i++)
  1162.             {
  1163.                 MapFileHeader->dataoffsets[i] = -1;
  1164.                 MapFileHeader->datalengths[i] = 0;
  1165.             }
  1166.  
  1167.             DirtyFlag = writeH = 1;
  1168.             SaveMap(0);
  1169.     }
  1170. }
  1171.  
  1172.  
  1173. ////////////////////////////////////////////////////
  1174. //
  1175. // Item - Switch Maps
  1176. //
  1177. ////////////////////////////////////////////////////
  1178. void Item_SwitchMap(void)
  1179. {
  1180.  char tstr[40];
  1181.  MapHeaderStr TempHead;
  1182.  int which1,which2;
  1183.  long temp;
  1184.  
  1185.  while(1)
  1186.  {
  1187.   if ((which1=SelectMap(1,CREATED,"TO SWAP"))==-1)
  1188.     return;
  1189.   LoadFile(mapname,(char huge *)&TempHead,
  1190.     MapFileHeader->dataoffsets[which1],sizeof(MapHeaderStr));
  1191.   strcpy(tstr,"TO SWAP WITH '");
  1192.   strcat(tstr,TempHead.name);
  1193.   strcat(tstr,"'");
  1194.   if ((which2=SelectMap(1,ANYLIST,tstr))==-1)
  1195.     return;
  1196.  
  1197.   if (which1==whichmap) // MAKE SURE THE CURRENTLY EDITED MAP GETS CHANGED!
  1198.     whichmap=which2;
  1199.   else
  1200.   if (which2==whichmap)
  1201.     whichmap=which1;
  1202.  
  1203.   temp=MapFileHeader->dataoffsets[which1];
  1204.  
  1205.   strcpy(tstr,MapNames[which1]);
  1206.   strcpy(MapNames[which1],MapNames[which2]);
  1207.   strcpy(MapNames[which2],tstr);
  1208.  
  1209.   MapFileHeader->dataoffsets[which1]=MapFileHeader->dataoffsets[which2];
  1210.   MapFileHeader->dataoffsets[which2]=temp;
  1211.   writeH=DirtyFlag=1;
  1212.  }
  1213. }
  1214.  
  1215. ////////////////////////////////////////////////////
  1216. //
  1217. // Item - Quit
  1218. //
  1219. ////////////////////////////////////////////////////
  1220. btype Qbuttons[]={{" Yes ",4,2,2},{" No ",12,2,1}},
  1221.       DoSaveb[]={{" Yes ",7,4,2},{" No ",14,4,1}};
  1222. DialogDef Qdialog={"Quit - Are you sure?",20,4,2,&Qbuttons[0],NULL},
  1223.       DoSaved={"The map has been modified.\n"
  1224.            "Do you want to SAVE it\n"
  1225.            "before exiting TED5?",26,6,2,&DoSaveb[0],NULL},
  1226.       DoCreated={"The map has been modified.\n"
  1227.              "Do you want to SAVE it\n"
  1228.              "before CREATING a new one?",26,6,2,&DoSaveb[0],NULL};
  1229.  
  1230. void Item_Quit(void)
  1231. {
  1232.  int button;
  1233.  
  1234.  button=DoDialog(&Qdialog);
  1235.  
  1236.  if (button==1)
  1237.    {
  1238.      TEDInfo->lastvid=videomode;
  1239.     TEDInfo->level=whichmap;
  1240.     TEDInfo->OldCgaXMS=0;
  1241.     TEDInfo->OldEgaXMS=0;
  1242.     TEDInfo->OldVgaXMS=0;
  1243.     TEDInfo->OldCgaXMSsize=0;
  1244.     TEDInfo->OldEgaXMSsize=0;
  1245.     TEDInfo->OldVgaXMSsize=0;
  1246.  
  1247.     TEDInfo->pflags=((planeton&1)<<6)|
  1248.             ((planemon&1)<<5)|
  1249.             ((planeion&1)<<4)|
  1250.             ((viewton&1)<<2)|
  1251.             ((viewmon&1)<<1)|
  1252.             (viewion&1);
  1253.  
  1254.     SaveTEDInfo();
  1255.     if (DirtyFlag)
  1256.       {
  1257.        button=DoDialog(&DoSaved);
  1258.        if (button==1)
  1259.      Item_SaveMap();
  1260.        if (!button)
  1261.      return;        // ESC exits
  1262.       }
  1263.     SaveOutputHeader();
  1264.     Quit("");
  1265.    }
  1266. }
  1267.  
  1268. ////////////////////////////////////////////////////
  1269. //
  1270. // Item - Edit Map Names
  1271. //
  1272. ////////////////////////////////////////////////////
  1273. char EMNstring[16];
  1274. btype EMNb[]={{EMNstring,1,4,1},
  1275.           {"                ",1,8,1},
  1276.           {" Exit ",7,11,1}};
  1277. DialogDef EMNd={"     MAP RENAME\n\nChange...\n\n\n\nTo..."
  1278.         ,20,13,3,&EMNb[0],NULL};
  1279.  
  1280. void Item_EditMapNames(void)
  1281. {
  1282.  int which,mapnum,redraw=0,omapnum,oxb,oyb;
  1283.  MapHeaderStr TempHeader;
  1284.  char temp[16];
  1285.  
  1286.  
  1287.  CheckForMapSave();
  1288.  omapnum=whichmap;
  1289.  oxb=xbase;
  1290.  oyb=ybase;
  1291.  
  1292.  if ((mapnum=SelectMap(1,CREATED,"TO RENAME"))<0)
  1293.    return;
  1294.  
  1295.  whichmap=mapnum;
  1296.  LoadMap(whichmap);
  1297.  strcpy(EMNstring,MapHeader.name);
  1298.  
  1299.  MouseHide();
  1300.  DrawDialog(&EMNd,1);
  1301.  GetDialogXY(&EMNd,&sx,&sy);
  1302.  MouseShow();
  1303.  which=2;
  1304. #pragma warn -rch
  1305.  goto badboy;
  1306.  
  1307.  do
  1308.  {
  1309.   which=CheckButtons(&EMNd);
  1310.  
  1311. badboy:
  1312. #pragma warn +rch
  1313.   switch(which)
  1314.   {
  1315.    case 1:
  1316.      RestoreBackground();
  1317.      if ((mapnum=SelectMap(1,CREATED,"TO RENAME"))<0)
  1318.        {
  1319.     if (redraw)
  1320.       DrawInfoBar();
  1321.  
  1322.     whichmap=omapnum;
  1323.     LoadMap(whichmap);
  1324.     xbase=oxb;
  1325.     ybase=oyb;
  1326.     return;
  1327.        }
  1328.  
  1329.      whichmap=mapnum;
  1330.      LoadMap(whichmap);
  1331.      strcpy(EMNstring,MapHeader.name);
  1332.      MouseHide();
  1333.      DrawDialog(&EMNd,1);
  1334.      MouseShow();
  1335.  
  1336.    case 2:
  1337.      MouseHide();
  1338.      GetButtonXY(&EMNd,1,&sx,&sy);
  1339.      print(EMNb[1].text);
  1340.      GetButtonXY(&EMNd,1,&sx,&sy);
  1341.      if (input(temp,15))
  1342.        {
  1343.     writeH=1;
  1344.     strcpy(MapHeader.name,temp);
  1345.     strcpy(MapNames[mapnum],temp);
  1346.     DirtyFlag=1;
  1347.     Item_SaveMap();
  1348.        }
  1349.      else
  1350.        {
  1351.     GetButtonXY(&EMNd,1,&sx,&sy);
  1352.     print(EMNb[1].text);
  1353.        }
  1354.      MouseShow();
  1355.      break;
  1356.  
  1357.    case 3:
  1358.      which=0;
  1359.   }
  1360.  } while(which);
  1361.  
  1362.  RestoreBackground();
  1363.  if (redraw)
  1364.    DrawInfoBar();
  1365.  
  1366.  whichmap=omapnum;
  1367.  LoadMap(whichmap);
  1368.  xbase=oxb;
  1369.  ybase=oyb;
  1370. }
  1371.  
  1372. ////////////////////////////////////////////////////
  1373. //
  1374. // Item - Paste Mode
  1375. //
  1376. ////////////////////////////////////////////////////
  1377. void Item_Paste(void)
  1378. {
  1379.  if (!TileCopy.w)
  1380.    return;
  1381.  
  1382.  ZeroModes();
  1383.  PasteMode=1;
  1384.  DrawInfoBar();
  1385.  px=(pixelx>>(tsize+2))+xbase;
  1386.  py=((pixely-8)>>(tsize+2))+ybase;
  1387. }
  1388.  
  1389. ////////////////////////////////////////////////////
  1390. //
  1391. // Item - Copy Mode
  1392. //
  1393. ////////////////////////////////////////////////////
  1394. void Item_Copy(void)
  1395. {
  1396.  ZeroModes();
  1397.  SelectMode=1;
  1398.  SelX1=SelY1=SelX2=SelY2=-1;
  1399.  DrawInfoBar();
  1400. }
  1401.  
  1402. ////////////////////////////////////////////////////
  1403. //
  1404. // Item - LastVideo
  1405. //
  1406. ////////////////////////////////////////////////////
  1407. void Item_LastVideo(void)
  1408. {
  1409.  int temp=videomode;
  1410.  
  1411.  
  1412.  videomode=lastvideo;
  1413.  lastvideo=temp;
  1414.  if (temp==EGA1)
  1415.      videomode=EGA2;
  1416.  else
  1417.      videomode=EGA1;
  1418.  
  1419.  switch(videomode)
  1420.  {
  1421.   case CGA:
  1422.      xmshandle=CgaXMS;
  1423.      XMSlookup=CgaXMSlookup;
  1424.      break;
  1425.   case EGA1:
  1426.   case EGA2:
  1427.      xmshandle=EgaXMS;
  1428.      XMSlookup=EgaXMSlookup;
  1429.      break;
  1430.   case VGA:
  1431.      xmshandle=VgaXMS;
  1432.      XMSlookup=VgaXMSlookup;
  1433.  }
  1434.  
  1435.  MouseHide();
  1436.  setvideo(videomode);
  1437.  InitDesktop(TED5MenuBar,0);
  1438.  DrawInfoBar();
  1439.  FigureScreenEdges();
  1440.  
  1441.  if (xbase+screenw>mapwidth)
  1442.     xbase=mapwidth-screenw;
  1443.  if (mapwidth<screenw)
  1444.     xbase=0;
  1445.  if (ybase+screenh>mapheight)
  1446.     ybase=mapheight-screenh;
  1447.  if (mapheight<screenh)
  1448.     ybase=0;
  1449.  
  1450.  DrawMap();
  1451.  MouseShow();
  1452. }
  1453.  
  1454. ////////////////////////////////////////////////////
  1455. //
  1456. // Item - Switch to the Last Map
  1457. //
  1458. ////////////////////////////////////////////////////
  1459. void Item_LastMap(void)
  1460. {
  1461.  int temp;
  1462.  
  1463.  if (!CheckForMapSave())
  1464.     return;
  1465.  
  1466.  if (lastmap==-1)
  1467.     {
  1468.      int which=SelectMap(1,CREATED,"TO EDIT");
  1469.     if (which==-1)
  1470.       return;
  1471.     lastmap=which;
  1472.    }
  1473.  
  1474.  temp=whichmap;
  1475.  whichmap=lastmap;
  1476.  lastmap=temp;
  1477.  
  1478.  LoadMap(whichmap);
  1479.  InitDesktop(TED5MenuBar,0);
  1480.  MouseShow();
  1481.  DrawMap();
  1482.  DrawInfoBar();
  1483. }
  1484.  
  1485. ////////////////////////////////////////////////////
  1486. //
  1487. // Item - Flood Fill!
  1488. //
  1489. ////////////////////////////////////////////////////
  1490. void Item_FloodFill(void)
  1491. {
  1492.  ZeroModes();
  1493.  FillMode=1;
  1494.  DrawInfoBar();
  1495. }
  1496.  
  1497. void DoFloodFill(int x,int y,int whichb)
  1498. {
  1499. #define NUMSPORES       500
  1500.  
  1501.  int obx[NUMSPORES],oby[NUMSPORES],i,used,j,width,k,highest,height,
  1502.      vectx[4]={0,1,0,-1},vecty[4]={-1,0,1,0},orgt,orgm,orgi,Ton,Mon,Ion;
  1503.  unsigned ptr,newoff,whichplanes=0,ctrl=0;
  1504.  int nx,ny,newt,newm,newi;
  1505.  
  1506.  
  1507.  if (keydown[0x1d] || whichb)
  1508.    ctrl++;
  1509.  
  1510.  whichplanes=planeton+planemon+planeion;
  1511.  if (whichplanes>1)
  1512.    {
  1513.      ErrDialog("I will only allow Flood Filling\n"
  1514.           "one plane at a time; you have\n"
  1515.           "more than one plane selected."," OK ");
  1516.     return;
  1517.    }
  1518.  
  1519.  for (i=0;i<NUMSPORES;i++)
  1520.    obx[i]=oby[i]=-1;
  1521.  
  1522.  obx[0]=x;
  1523.  oby[0]=y;
  1524.  newoff=ptr=oby[0]*mapwidth+obx[0];
  1525.  width=MapHeader.width;
  1526.  height=MapHeader.height;
  1527.  used=1;
  1528.  highest=1;
  1529.  if (obx[0]<0 || oby[0]<0 || obx[0]>width || oby[0]>height)
  1530.    {
  1531.     FillMode=0;
  1532.     DrawInfoBar();
  1533.     return;
  1534.    }
  1535.  
  1536.  Ton=planeton;
  1537.  Mon=planemon;
  1538.  Ion=planeion;
  1539.  
  1540.  orgt=*(MapBkgnd+ptr);
  1541.  orgm=*(MapFrgnd+ptr);
  1542.  orgi=*(MapInfoPl+ptr);
  1543.  
  1544.  if (((Ton?whicht==orgt:0) ||
  1545.      (Mon?whichtm-tilenum==orgm:0) ||
  1546.      (Ion?whichi-tilenum==orgi:0)) && !ctrl)
  1547.    {
  1548.     FillMode=0;
  1549.     DrawInfoBar();
  1550.     return;
  1551.    }
  1552.  
  1553.  MouseHide();
  1554.  CopyUndoRegion();
  1555.  UndoRegion.x=UndoRegion.y=0;
  1556.  UndoRegion.w=mapwidth;
  1557.  UndoRegion.h=mapheight;
  1558.  
  1559.  if (ctrl)
  1560.    {
  1561.     unsigned from=(TileCopy.y+(y%TileCopy.h))*mapwidth+
  1562.       TileCopy.x+(x%TileCopy.w);
  1563.  
  1564.     switch(TileCopy.MapOrTileSelect)
  1565.     {
  1566.      case 0: // COPY BUFFER
  1567.        Ton=TileCopy.PlanesCopied&BPLANE;
  1568.        Mon=TileCopy.PlanesCopied&FPLANE;
  1569.        Ion=TileCopy.PlanesCopied&IPLANE;
  1570.  
  1571.        newt=CutBkgnd[from];
  1572.        newm=CutFrgnd[from];
  1573.        newi=CutInfoPl[from];
  1574.  
  1575.        break;
  1576.      case 1: // TILES
  1577.        Ton=1;
  1578.        Mon=Ion=0;
  1579.  
  1580.        newt=((y%TileCopy.h)+TileCopy.y)*selectcols+
  1581.         TileCopy.x+(x%TileCopy.w);
  1582.        if (XMSlookup[newt]<0)
  1583.      Ton=0;
  1584.        break;
  1585.      case 2: // MASKED
  1586.        Ton=Ion=0;
  1587.        Mon=1;
  1588.  
  1589.        newm=((y%TileCopy.h)+TileCopy.y)*selectcols+
  1590.         TileCopy.x+(x%TileCopy.w)+tilenum+maxiconrows*selectcols;
  1591.        if (XMSlookup[newm]<0)
  1592.      Mon=0;
  1593.        else
  1594.      newm-=tilenum;
  1595.     }
  1596.    }
  1597.  else
  1598.    {
  1599.     newt=whicht;
  1600.     newm=whichtm-tilenum;
  1601.     newi=whichi-tilenum;
  1602.    }
  1603.  
  1604.  if (Ton)
  1605.    *(MapBkgnd+newoff)=newt;
  1606.  if (Mon)
  1607.    *(MapFrgnd+newoff)=newm;
  1608.  if (Ion)
  1609.    *(MapInfoPl+newoff)=newi;
  1610.  
  1611.  do
  1612.    {
  1613.     for (i=0;i<=highest;i++)
  1614.       //
  1615.       // SEE IF SPORE EXISTS
  1616.       //
  1617.       if (obx[i]!=-1)
  1618.     {
  1619.      //
  1620.      // DRAW TILE AT SPORE IF IT'S ONSCREEN
  1621.      //
  1622.      if (oby[i]>=ybase && oby[i]<ybase+screenh &&
  1623.          obx[i]>=xbase && obx[i]<xbase+screenw)
  1624.          {
  1625.           unsigned oldt,oldm,oldi,off;
  1626.  
  1627.           off=oby[i]*width+obx[i];
  1628.  
  1629.           oldt=*(MapBkgnd+off);
  1630.           oldm=*(MapFrgnd+off)+tilenum;
  1631.           oldi=*(MapInfoPl+off)+tilenum;
  1632.  
  1633.           CombineTiles(viewton?oldt:-BkgndColor,
  1634.                viewmon?oldm:0,
  1635.                viewion?oldi:0,
  1636.                tsize);
  1637.           DrawTile((obx[i]-xbase)<<(tsize-1),((oby[i]-ybase)<<(tsize+2))+8,tsize);
  1638.          }
  1639.  
  1640.      //
  1641.      // FREE THIS SPORE
  1642.      //
  1643.      x=obx[i];
  1644.      y=oby[i];
  1645.      obx[i]=-1;
  1646.      used--;
  1647.  
  1648.      //
  1649.      // SEARCH 4 QUADRANTS FOR A SPORE TO FILL
  1650.      // (ONLY 4 QUADS SO WE DON'T FILL THRU DIAGONALS)
  1651.      //
  1652.      if (!ctrl)
  1653.      for (j=0;j<4;j++)
  1654.        {
  1655.         newoff=(y+vecty[j])*mapwidth+x+vectx[j];
  1656.  
  1657.         if ((Ton?*(MapBkgnd+newoff)==orgt:1) &&
  1658.         (Mon?*(MapFrgnd+newoff)==orgm:1) &&
  1659.         (Ion?*(MapInfoPl+newoff)==orgi:1))
  1660.           {
  1661.            for (k=0;k<NUMSPORES;k++)
  1662.          if (obx[k]==-1)
  1663.            {
  1664.             obx[k]=x+vectx[j];
  1665.             oby[k]=y+vecty[j];
  1666.             if (obx[k]<0 || obx[k]>width || oby[k]<0 || oby[k]>height)
  1667.               {
  1668.                obx[k]=-1;
  1669.                break;
  1670.               }
  1671.  
  1672.             used++;
  1673.             if (Ton)
  1674.               *(MapBkgnd+newoff)=whicht;
  1675.             if (Mon)
  1676.               *(MapFrgnd+newoff)=whichtm-tilenum;
  1677.             if (Ion)
  1678.               *(MapInfoPl+newoff)=whichi-tilenum;
  1679.             DirtyFlag=1;
  1680.             if (k>highest)
  1681.               highest=k;
  1682.             break;
  1683.            }
  1684.           }
  1685.  
  1686.         if (keydown[1])     // ESC OUT
  1687.           {
  1688.            while(keydown[1]);
  1689.            goto done;
  1690.           }
  1691.        }
  1692.      else
  1693.      for (j=0;j<4;j++)
  1694.        {
  1695.         unsigned from;
  1696.  
  1697.         ny=y+vecty[j];
  1698.         nx=x+vectx[j];
  1699.  
  1700.         newoff=ny*mapwidth+nx;
  1701.  
  1702.         if ((Ton?*(MapBkgnd+newoff)==orgt:1) &&
  1703.         (Mon?*(MapFrgnd+newoff)==orgm:1) &&
  1704.         (Ion?*(MapInfoPl+newoff)==orgi:1))
  1705.           {
  1706.            for (k=0;k<NUMSPORES;k++)
  1707.          if (obx[k]==-1)
  1708.            {
  1709.             obx[k]=nx;
  1710.             oby[k]=ny;
  1711.             if (obx[k]<0 || obx[k]>width || oby[k]<0 || oby[k]>height)
  1712.               {
  1713.                obx[k]=-1;
  1714.                break;
  1715.               }
  1716.  
  1717.             from=(TileCopy.y+(ny%TileCopy.h))*mapwidth+
  1718.              TileCopy.x+(nx%TileCopy.w);
  1719.  
  1720.             switch(TileCopy.MapOrTileSelect)
  1721.             {
  1722.              case 0: // COPY BUFFER
  1723.                Ton=TileCopy.PlanesCopied&BPLANE;
  1724.                Mon=TileCopy.PlanesCopied&FPLANE;
  1725.                Ion=TileCopy.PlanesCopied&IPLANE;
  1726.  
  1727.                newt=CutBkgnd[from];
  1728.                newm=CutFrgnd[from];
  1729.                newi=CutInfoPl[from];
  1730.  
  1731.                break;
  1732.              case 1: // TILES
  1733.                Ton=1;
  1734.                Mon=Ion=0;
  1735.  
  1736.                newt=((ny%TileCopy.h)+TileCopy.y)*selectcols+
  1737.                 TileCopy.x+(nx%TileCopy.w);
  1738.                  if (XMSlookup[newt]<0)
  1739.              Ton=0;
  1740.                break;
  1741.              case 2: // MASKED
  1742.                Ton=Ion=0;
  1743.                Mon=1;
  1744.  
  1745.                newm=((ny%TileCopy.h)+TileCopy.y)*selectcols+
  1746.                 TileCopy.x+(nx%TileCopy.w)+tilenum+maxiconrows*selectcols;
  1747.                if (XMSlookup[newm]<0)
  1748.              Mon=0;
  1749.                else
  1750.              newm-=tilenum;
  1751.             }
  1752.  
  1753.             if (Ton)
  1754.               *(MapBkgnd+newoff)=newt;
  1755.             if (Mon)
  1756.               *(MapFrgnd+newoff)=newm;
  1757.             if (Ion)
  1758.               *(MapInfoPl+newoff)=newi;
  1759.             used++;
  1760.  
  1761.             DirtyFlag=1;
  1762.             if (k>highest)
  1763.               highest=k;
  1764.             break;
  1765.            }
  1766.           }
  1767.  
  1768.         if (keydown[1])     // ESC OUT
  1769.           {
  1770.            while(keydown[1]);
  1771.            goto done;
  1772.           }
  1773.        }
  1774.     }
  1775.    } while(used);
  1776.  
  1777. done:
  1778.  DrawMap();
  1779.  MouseShow();
  1780.  FillMode=0;
  1781.  DrawInfoBar();
  1782. }
  1783.  
  1784.  
  1785.  
  1786. ////////////////////////////////////////////////////
  1787. //
  1788. // If map has been changed, ask user if they want
  1789. // to SAVE it before continuing.
  1790. //
  1791. ////////////////////////////////////////////////////
  1792. btype oktosaveB[]={{" Yes ",10,2,2},{" No ",20,2,1}};
  1793. DialogDef oktosaveD={"The map has been modified!\n"
  1794.              "Save it?",26,4,2,&oktosaveB[0],NULL};
  1795.  
  1796. int CheckForMapSave(void)
  1797. {
  1798.  if (DirtyFlag)
  1799.    {
  1800.     int which=DoDialog(&oktosaveD);
  1801.     if (!which)
  1802.       return 0;
  1803.     if (which==1)
  1804.       Item_SaveMap();
  1805.    }
  1806.  return 1;
  1807. }
  1808.  
  1809.  
  1810. ////////////////////////////////////////////////////
  1811. //
  1812. // Zero all special mode flags
  1813. //
  1814. ////////////////////////////////////////////////////
  1815. void ZeroModes(void)
  1816. {
  1817.  SelX1=SelX2=SelY1=SelY2=-1;
  1818.  if (BfillMode || SelectMode || PasteMode || FillMode)
  1819.  {
  1820.   DrawMap();
  1821.   DrawInfoBar();
  1822.  }
  1823.  
  1824.  BfillMode=SelectMode=PasteMode=FillMode=0;
  1825. }
  1826.  
  1827.  
  1828. ////////////////////////////////////////////////////
  1829. //
  1830. // Item - Count Map Tiles
  1831. //
  1832. ////////////////////////////////////////////////////
  1833. btype CMTb[]={
  1834.           {" Exit ",9,20,2},
  1835.           {" TILE ",1,20,1},
  1836.           {" MASKED ",17,20,1},
  1837.           {" Rebuild ",27,20,1}
  1838.          };
  1839. DialogDef CMTd={"        Count Unused Map Tiles",38,22,4,&CMTb[0],0};
  1840. unsigned char _seg *tarray,_seg *tmarray,thesparse;
  1841.  
  1842.  
  1843. void Item_CountTiles(void)
  1844. {
  1845.  enum {TILE,TILEM};
  1846.  
  1847.  unsigned i,j,dx,dy,max,exit=0,numt,numtm,oxbase,oybase,nsize,nmsize,redraw;
  1848.  int which,dumrow,dumcol;
  1849.  char pb,pf,pi;
  1850.  
  1851.  
  1852.  CheckForMapSave();
  1853.  
  1854.  oxbase=xbase;
  1855.  oybase=ybase;
  1856.  
  1857.  //
  1858.  // COMPUTE SIZE OF EACH TILE
  1859.  //
  1860.  switch(videomode)
  1861.  {
  1862.   case CGA: nsize=16; nmsize=32; break;
  1863.   case EGA1:
  1864.   case EGA2: nsize=32; nmsize=40; break;
  1865.   case VGA: nsize=64; nmsize=128;
  1866.  }
  1867.  nsize=nsize<<((tsize-1)<<1);
  1868.  nmsize=nmsize<<((tsize-1)<<1);
  1869.  
  1870.  
  1871.  MouseHide();
  1872.  DrawDialog(&CMTd,1);
  1873.  GetDialogXY(&CMTd,&dx,&dy);
  1874.  sx=dx+4;
  1875.  sy=dy+2;
  1876.  print("Counting tiles in map:");
  1877.  MouseShow();
  1878.  
  1879.  MMAllocate((memptr *)&tarray,tilenum);
  1880.  MMAllocate((memptr *)&tmarray,tilemnum);
  1881.  _fmemset(tarray,0,tilenum);
  1882.  _fmemset(tmarray,0,tilemnum);
  1883.  
  1884.  //
  1885.  // Now, load each map in & count the tiles
  1886.  //
  1887.  pb=MapFileHeader->maptype&BPLANE;
  1888.  pf=MapFileHeader->maptype&FPLANE;
  1889.  pi=MapFileHeader->maptype&IPLANE;
  1890.  
  1891.  for (i=0;i<100;i++)
  1892.    if (MapFileHeader->dataoffsets[i]>=0)
  1893.      {
  1894.       sx=dx+26;
  1895.       sy=dy+2;
  1896.       printint(i);
  1897.  
  1898.       LoadMap(i);
  1899.       max=mapwidth*mapheight;
  1900.       for (j=0;j<max;j++)
  1901.     {
  1902.      if (pb)
  1903.         tarray[MapBkgnd[j]]=1;
  1904.      if (pf)
  1905.         tmarray[MapFrgnd[j]]=1;
  1906.      if (pi)
  1907.         tmarray[MapInfoPl[j]]=1;
  1908.     }
  1909.      }
  1910.  
  1911.  //
  1912.  // Find a SPARSE tile
  1913.  //
  1914.  for (i=0;i<tilenum;i++)
  1915.    if (XMSlookup[i]<0)
  1916.      {
  1917.       thesparse=i;
  1918.       break;
  1919.      }
  1920.  
  1921.  //
  1922.  // Count unused amount
  1923.  //
  1924.  numt=0;
  1925.  for (i=0;i<tilenum;i++)
  1926.    if (XMSlookup[i]>=0 && !tarray[i])
  1927.      numt++;
  1928.  
  1929.  numtm=0;
  1930.  for (i=0;i<tilemnum;i++)
  1931.    if (XMSlookup[i+tilenum]>=0 && !tmarray[i])
  1932.      numtm++;
  1933.  
  1934.  
  1935.  //
  1936.  // INPUT FROM DIALOG
  1937.  //
  1938.  do
  1939.  {
  1940.   MouseHide();
  1941.   xormask=0;
  1942.   sx=dx+2;
  1943.   sy=dy+17;
  1944.   print("Unused TILES:");
  1945.   printint(numt);
  1946.   print(", unused MASKED:");
  1947.   printint(numtm);
  1948.   print(" ");
  1949.   sx=dx+2;
  1950.   sy=dy+18;
  1951.   print("TILE Memory:");
  1952.   printint((1023l+(long)numt*nsize)/1024);
  1953.   print("K, MASKED Memory:");
  1954.   printint((1023l+(long)numtm*nmsize)/1024);
  1955.   print("K ");
  1956.   MouseShow();
  1957.   DrawUnused(0);
  1958.   redraw=0;
  1959.  
  1960.   do
  1961.   {
  1962.    if (!MouseButton())
  1963.      which=CheckButtonsRet(&CMTd);
  1964.    MouseCoords(&pixelx,&pixely);
  1965.    pixelx/=8;
  1966.    pixely/=8;
  1967.    if (MouseButton() && pixelx>dx && pixelx<dx+37 && pixely>dy && pixely<dy+18)
  1968.      {
  1969.       int tile=((pixelx-dx-1)>>(tsize-1))+((pixely-dy-1)>>(tsize-1))*(9<<(3-tsize));
  1970.  
  1971.       switch(whichscreen)
  1972.       {
  1973.        case TILES:
  1974.      if (!tarray[tile+tilebase] && XMSlookup[tile+tilebase]>=0)
  1975.        {
  1976.         tarray[tile+tilebase]=1;
  1977.         numt--;
  1978.         redraw=1;
  1979.        }
  1980.      break;
  1981.        case MASKED:
  1982.      if (!tmarray[tile+tilembase] && XMSlookup[tilenum+tile+tilembase]>=0)
  1983.        {
  1984.         tmarray[tile+tilembase]=1;
  1985.         numtm--;
  1986.         redraw=1;
  1987.        }
  1988.       }
  1989.       continue;
  1990.      }
  1991.  
  1992.    switch(which)
  1993.    {
  1994.     case 0:
  1995.     case 1:
  1996.       exit=1;
  1997.       continue;
  1998.  
  1999.     case 2:
  2000.       MouseHide();
  2001.       GetButtonXY(&CMTd,which-1,&sx,&sy);
  2002.       print(CMTb[which-1].text);
  2003.       whichscreen=TILES;
  2004.       DrawUnused(0);
  2005.       MouseShow();
  2006.       continue;
  2007.  
  2008.     case 3:
  2009.       MouseHide();
  2010.       GetButtonXY(&CMTd,which-1,&sx,&sy);
  2011.       print(CMTb[which-1].text);
  2012.       whichscreen=MASKED;
  2013.       DrawUnused(0);
  2014.       MouseShow();
  2015.       continue;
  2016.  
  2017.     //
  2018.     // REBUILD GRAPHICS FILE & HEADER
  2019.     //
  2020.     case 4:
  2021.       {
  2022.        char newgfx[13]="NEW?GA.",
  2023.         newhead[13]="NEW?HEAD.",
  2024.         newhobj[13]="NEW?HEAD.",
  2025.         oldhead[13]="?GAHEAD.";
  2026.  
  2027.        char _seg *gfxhead;
  2028.  
  2029.  
  2030.        newgfx[3]=format[0];
  2031.        newhead[3]=format[0];
  2032.        newhobj[3]=format[0];
  2033.        oldhead[0]=format[0];
  2034.  
  2035.  
  2036.        LoadIn(oldhead,(memptr *)&gfxhead);
  2037.        for (i=0;i<tilenum;i++)
  2038.        {
  2039.     if (tarray[i])
  2040.       *(gfxhead+i*3)=*(gfxhead+i*3);
  2041.        }
  2042.  
  2043.  
  2044.       }
  2045.       continue;
  2046.    }
  2047.    //
  2048.    // KEY CHECKS
  2049.    //
  2050.    if (keydown[1])
  2051.      {
  2052.       exit=1;
  2053.       continue;
  2054.      }
  2055.    else
  2056.    if (keydown[0x50])
  2057.      DrawUnused(1);
  2058.    else
  2059.    if (keydown[0x48])
  2060.      DrawUnused(-1);
  2061.    else
  2062.    if (keydown[0x49])
  2063.      {
  2064.       DrawUnused(-8);
  2065.       while(keydown[0x49]);
  2066.      }
  2067.    else
  2068.    if (keydown[0x51])
  2069.      {
  2070.       DrawUnused(8);
  2071.       while(keydown[0x51]);
  2072.      }
  2073.  
  2074.   } while(!redraw && !exit);
  2075.  } while(!exit);
  2076.  
  2077.  RestoreBackground();
  2078.  LoadMap(whichmap);
  2079.  tilebase=tilembase=0;
  2080.  
  2081.  xbase=oxbase;
  2082.  ybase=oybase;
  2083. }
  2084.  
  2085.  
  2086. //
  2087. // FILL THE "UNUSED TILES" SCREEN WITH TILES
  2088. //
  2089. void DrawUnused(int deltarow)
  2090. {
  2091.  char tile[32*32];
  2092.  int numcols,numrows,i,j,top;
  2093.  
  2094.  if (whichscreen==ICONS)
  2095.    whichscreen=TILES;
  2096.  
  2097.  MouseHide();
  2098.  
  2099.  numrows=18-10*(tsize==2)-15*(tsize==3);
  2100.  left=2;
  2101.  top=2*8;
  2102.  if (videomode==EGA2)
  2103.    {
  2104.     left=22;
  2105.     top=20*8;
  2106.    }
  2107.  
  2108.  switch(tsize)
  2109.  {
  2110.   case 1: numcols=36; break;
  2111.   case 2: numcols=18; break;
  2112.   case 3: numcols=9;
  2113.  }
  2114.  
  2115.  if (whichscreen==TILES && tilebase+numrows*numcols>tilenum)
  2116.    {
  2117.     tilebase=0;
  2118.     numrows=tilenum/numcols;
  2119.    }
  2120.  
  2121.  if (whichscreen==MASKED && tilembase+numrows*numcols>tilemnum)
  2122.    {
  2123.     tilembase=0;
  2124.     numrows=tilemnum/numcols;
  2125.    }
  2126.  
  2127.  switch((deltarow<0?-1:deltarow>0?1:0))
  2128.  {
  2129.   case -1:
  2130.    switch(whichscreen)
  2131.    {
  2132.     case TILES:
  2133.       tilebase+=deltarow*numcols;
  2134.       if (tilebase<0)
  2135.     tilebase=0;
  2136.       break;
  2137.     case MASKED:
  2138.       tilembase+=deltarow*numcols;
  2139.       if (tilembase<0)
  2140.     tilembase=0;
  2141.    }
  2142.    break;
  2143.   case 1:
  2144.    switch(whichscreen)
  2145.    {
  2146.     case TILES:
  2147.       tilebase+=deltarow*numcols;
  2148.       if (tilebase+numrows*numcols>tilenum)
  2149.     tilebase=tilenum-numcols*numrows;
  2150.       break;
  2151.     case MASKED:
  2152.       tilembase+=deltarow*numcols;
  2153.       if (tilembase+numrows*numcols>tilemnum)
  2154.     tilembase=tilemnum-numcols*numrows;
  2155.    }
  2156.  }
  2157.  
  2158.  switch(whichscreen)
  2159.  {
  2160.   case TILES:
  2161.     for(j=0;j<numrows;j++)
  2162.       for(i=0;i<numcols;i++)
  2163.       {
  2164.        if (!tarray[tilebase+j*numcols+i] && XMSlookup[tilebase+j*numcols+i]>=0)
  2165.      CombineTiles(tilebase+j*numcols+i,0,0,tsize);
  2166.        else
  2167.      CombineTiles(thesparse,0,0,tsize);
  2168.        DrawTile(i*2+left,j*16+top,tsize);
  2169.       }
  2170.     break;
  2171.  
  2172.   case MASKED:
  2173.     for(j=0;j<numrows;j++)
  2174.       for(i=0;i<numcols;i++)
  2175.       {
  2176.        if (!tmarray[tilembase+j*numcols+i] && XMSlookup[tilenum+tilembase+j*numcols+i]>=0)
  2177.      CombineTiles(-BkgndColor,tilenum+tilembase+j*numcols+i,0,tsize);
  2178.        else
  2179.      CombineTiles(thesparse,0,0,tsize);
  2180.        DrawTile(i*2+left,j*16+top,tsize);
  2181.       }
  2182.  }
  2183.  MouseShow();
  2184. }
  2185.